package com.example.testplatform.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.testplatform.common.LogUtils;
import com.example.testplatform.entity.User;
import com.example.testplatform.mapper.UserMapper;
import com.example.testplatform.service.UserService;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 用户Service实现类
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    private static final Logger logger = LogUtils.getLogger(UserServiceImpl.class);

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public User getByUsername(String username) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "USER_QUERY_BY_USERNAME_START", "system", "准备根据用户名查询用户，用户名: " + username);
        try {
            // 参数验证
            if (username == null || username.trim().isEmpty()) {
                LogUtils.warn(logger, "【用户管理】getByUsername方法参数验证失败: 用户名为空");
                LogUtils.logBusiness(logger, "USER_QUERY_BY_USERNAME_FAILED", "system", "根据用户名查询用户参数验证失败: 用户名为空");
                return null;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】开始执行getByUsername方法，用户名: " + username);
            LogUtils.debug(logger, () -> "【用户管理】getByUsername方法执行开始时间戳: " + startTime);
            
            LogUtils.debug(logger, () -> "【用户管理】调用userMapper.selectByUsername方法查询数据库，用户名: " + username);
            User user = userMapper.selectByUsername(username);
            
            LogUtils.debug(logger, () -> "【用户管理】数据库查询完成，开始处理查询结果");
            if (user == null) {
                LogUtils.debug(logger, () -> "【用户管理】未找到用户: " + username);
                LogUtils.info(logger, () -> "【用户管理】根据用户名 " + username + " 查询用户，结果: 未找到");
                LogUtils.logBusiness(logger, "USER_QUERY_BY_USERNAME_NOT_FOUND", "system", "根据用户名查询用户未找到: " + username);
            } else {
                LogUtils.debug(logger, () -> "【用户管理】找到用户: " + username + ", ID: " + user.getId());
                LogUtils.info(logger, () -> "【用户管理】根据用户名 " + username + " 查询用户成功，用户ID: " + user.getId() + ", 状态: " + user.getStatus());
                LogUtils.logBusiness(logger, "USER_QUERY_BY_USERNAME_SUCCESS", "system", "根据用户名查询用户成功: " + username + ", 用户ID: " + user.getId());
            }
            
            LogUtils.logPerformance(logger, "getByUsername", startTime, System.currentTimeMillis());
            LogUtils.debug(logger, () -> "【用户管理】getByUsername方法执行完成，返回查询结果");
            return user;
        } catch (Exception e) {
            LogUtils.error(logger, "【用户管理】根据用户名查询用户异常: " + username + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "USER_QUERY_BY_USERNAME_ERROR", "system", "根据用户名查询用户发生异常: " + username + ", " + e.getMessage());
            throw e;
        }
    }

    @Override
    public User login(String username, String password) {
        long startTime = System.currentTimeMillis();
        LogUtils.logSecurityEvent(logger, "USER_LOGIN_ATTEMPT", username, "用户登录尝试开始");
        try {
            // 参数验证
            if (username == null || username.trim().isEmpty()) {
                LogUtils.warn(logger, "【用户管理】login方法参数验证失败: 用户名为空");
                LogUtils.logSecurityEvent(logger, "USER_LOGIN_FAILED", username, "登录验证失败: 用户名为空");
                return null;
            }
            if (password == null || password.trim().isEmpty()) {
                LogUtils.warn(logger, "【用户管理】login方法参数验证失败: 密码为空，用户名: {}", username);
                LogUtils.logSecurityEvent(logger, "USER_LOGIN_FAILED", username, "登录验证失败: 密码为空");
                return null;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】开始执行login方法进行用户登录验证，用户名: " + username);
            LogUtils.debug(logger, () -> "【用户管理】login方法执行开始时间戳: " + startTime);
            
            // 查询用户
            LogUtils.debug(logger, () -> "【用户管理】调用getByUsername方法查询用户信息，用户名: " + username);
            User user = getByUsername(username);
            
            if (user == null) {
                LogUtils.warn(logger, "【用户管理】登录失败: 用户不存在，用户名: {}", username);
                LogUtils.logSecurityEvent(logger, "USER_LOGIN_FAILED", username, "登录验证失败: 用户不存在");
                return null;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】用户存在，检查用户状态，用户ID: " + user.getId() + ", 状态: " + user.getStatus());
            if (user.getStatus() == 0) {
                LogUtils.warn(logger, "【用户管理】登录失败: 用户已禁用，用户名: {}", username);
                LogUtils.logSecurityEvent(logger, "USER_LOGIN_FAILED", username, "登录验证失败: 用户已禁用");
                return null;
            }
            
            // 验证密码
            LogUtils.debug(logger, () -> "【用户管理】开始验证用户密码，用户名: " + username);
            boolean passwordMatch = passwordEncoder.matches(password, user.getPassword());
            LogUtils.debug(logger, () -> "【用户管理】密码验证结果: " + passwordMatch);
            
            if (!passwordMatch) {
                LogUtils.warn(logger, "【用户管理】登录失败: 密码错误，用户名: {}", username);
                LogUtils.logSecurityEvent(logger, "USER_LOGIN_FAILED", username, "登录验证失败: 密码错误");
                return null;
            }
            
            LogUtils.info(logger, () -> "【用户管理】用户登录成功，用户名: " + username + ", 用户ID: " + user.getId());
            LogUtils.logSecurityEvent(logger, "USER_LOGIN_SUCCESS", username, "用户登录成功，用户ID: " + user.getId());
            
            LogUtils.logPerformance(logger, "login", startTime, System.currentTimeMillis());
            LogUtils.debug(logger, () -> "【用户管理】login方法执行完成，返回用户信息");
            return user;
        } catch (Exception e) {
            LogUtils.error(logger, "【用户管理】用户登录验证异常: " + username + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logSecurityEvent(logger, "USER_LOGIN_ERROR", username, "用户登录发生异常: " + e.getMessage());
            throw e;
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean register(User user) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "USER_REGISTER_ATTEMPT", "system", "用户注册尝试开始");
        try {
            // 参数验证
            if (user == null) {
                LogUtils.warn(logger, "【用户管理】register方法参数验证失败: 用户对象为空");
                LogUtils.logBusiness(logger, "USER_REGISTER_FAILED", "system", "用户注册失败: 用户对象为空");
                return false;
            }
            if (user.getUsername() == null || user.getUsername().trim().isEmpty()) {
                LogUtils.warn(logger, "【用户管理】register方法参数验证失败: 用户名为空");
                LogUtils.logBusiness(logger, "USER_REGISTER_FAILED", "system", "用户注册失败: 用户名为空");
                return false;
            }
            if (user.getPassword() == null || user.getPassword().trim().isEmpty()) {
                LogUtils.warn(logger, "【用户管理】register方法参数验证失败: 密码为空，用户名: {}", user.getUsername());
                LogUtils.logBusiness(logger, "USER_REGISTER_FAILED", "system", "用户注册失败: 密码为空，用户名: " + user.getUsername());
                return false;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】开始执行register方法进行用户注册，用户名: " + user.getUsername());
            LogUtils.debug(logger, () -> "【用户管理】注册方法执行开始时间戳: " + startTime);
            
            // 检查用户名是否已存在
            LogUtils.debug(logger, () -> "【用户管理】检查用户名是否已存在，用户名: " + user.getUsername());
            User existingUser = getByUsername(user.getUsername());
            if (existingUser != null) {
                LogUtils.warn(logger, "【用户管理】用户名已存在: {}", user.getUsername());
                LogUtils.logBusiness(logger, "USER_REGISTER_FAILED", "system", "用户注册失败: 用户名已存在: " + user.getUsername());
                return false;
            }
            
            LogUtils.info(logger, () -> "【用户管理】用户名可用，开始处理用户注册信息，用户名: " + user.getUsername());
            
            // 密码加密
            LogUtils.debug(logger, () -> "【用户管理】开始加密用户密码，用户名: " + user.getUsername());
            user.setPassword(passwordEncoder.encode(user.getPassword()));
            LogUtils.debug(logger, () -> "【用户管理】密码加密完成，用户名: " + user.getUsername());
            
            // 设置默认值
            LogUtils.debug(logger, () -> "【用户管理】设置用户默认值，用户名: " + user.getUsername());
            user.setStatus(1);
            user.setCreateTime(LocalDateTime.now());
            user.setUpdateTime(LocalDateTime.now());
            
            LogUtils.debug(logger, () -> "【用户管理】用户信息准备完成，开始保存用户数据，用户名: " + user.getUsername());
            boolean result = save(user);
            
            if (result) {
                LogUtils.info(logger, () -> "【用户管理】用户保存成功: " + user.getUsername() + ", ID: " + user.getId());
                LogUtils.logBusiness(logger, "USER_REGISTER_SUCCESS", "system", "用户注册成功: " + user.getUsername() + ", ID: " + user.getId());
                // 记录用户的详细注册信息（但不记录密码等敏感信息）
                LogUtils.debug(logger, () -> "【用户管理】用户注册完成详细信息: 用户名=" + user.getUsername() + ", 用户ID=" + user.getId() + ", 状态=" + user.getStatus() + ", 创建时间=" + user.getCreateTime());
            } else {
                LogUtils.warn(logger, "【用户管理】用户保存失败: {}", user.getUsername());
                LogUtils.logBusiness(logger, "USER_REGISTER_FAILED", "system", "用户保存失败: " + user.getUsername());
            }
            
            LogUtils.logPerformance(logger, "register", startTime, System.currentTimeMillis());
            LogUtils.debug(logger, () -> "【用户管理】register方法执行完成，结果: " + result);
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【用户管理】注册用户过程中发生异常: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "USER_REGISTER_ERROR", "system", "用户注册发生异常: " + e.getMessage());
            LogUtils.logPerformance(logger, "register", startTime, System.currentTimeMillis());
            throw e;
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updatePassword(Long userId, String oldPassword, String newPassword) {
        long startTime = System.currentTimeMillis();
        LogUtils.logSecurityEvent(logger, "PASSWORD_UPDATE_ATTEMPT", "user_" + userId, "用户密码更新尝试开始");
        try {
            // 参数验证
            if (userId == null || userId <= 0) {
                LogUtils.warn(logger, "【用户管理】updatePassword方法参数验证失败: 用户ID为空或非法值: " + userId);
                LogUtils.logSecurityEvent(logger, "PASSWORD_UPDATE_FAILED", "user_" + userId, "更新密码失败: 用户ID非法");
                return false;
            }
            if (oldPassword == null || oldPassword.trim().isEmpty()) {
                LogUtils.warn(logger, "【用户管理】updatePassword方法参数验证失败: 旧密码为空，用户ID: {}", userId);
                LogUtils.logSecurityEvent(logger, "PASSWORD_UPDATE_FAILED", "user_" + userId, "更新密码失败: 旧密码为空");
                return false;
            }
            if (newPassword == null || newPassword.trim().isEmpty()) {
                LogUtils.warn(logger, "【用户管理】updatePassword方法参数验证失败: 新密码为空，用户ID: {}", userId);
                LogUtils.logSecurityEvent(logger, "PASSWORD_UPDATE_FAILED", "user_" + userId, "更新密码失败: 新密码为空");
                return false;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】开始执行updatePassword方法更新用户密码，用户ID: " + userId);
            LogUtils.debug(logger, () -> "【用户管理】updatePassword方法执行开始时间戳: " + startTime);
            
            // 查询用户
            LogUtils.debug(logger, () -> "【用户管理】根据用户ID查询用户信息，用户ID: " + userId);
            User user = getById(userId);
            if (user == null) {
                LogUtils.warn(logger, "【用户管理】更新密码失败: 用户不存在，用户ID: {}", userId);
                LogUtils.logSecurityEvent(logger, "PASSWORD_UPDATE_FAILED", "user_" + userId, "更新密码失败: 用户不存在");
                return false;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】用户存在，开始验证旧密码，用户ID: " + userId);
            // 验证旧密码
            if (!passwordEncoder.matches(oldPassword, user.getPassword())) {
                LogUtils.warn(logger, "【用户管理】更新密码失败: 旧密码错误，用户ID: {}", userId);
                LogUtils.logSecurityEvent(logger, "PASSWORD_UPDATE_FAILED", "user_" + userId, "更新密码失败: 旧密码错误");
                return false;
            }
            
            LogUtils.info(logger, () -> "【用户管理】旧密码验证成功，开始更新为新密码，用户ID: " + userId);
            // 加密新密码
            LogUtils.debug(logger, () -> "【用户管理】开始加密新密码，用户ID: " + userId);
            user.setPassword(passwordEncoder.encode(newPassword));
            user.setUpdateTime(LocalDateTime.now());
            
            LogUtils.debug(logger, () -> "【用户管理】密码加密完成，开始保存更新后的用户信息，用户ID: " + userId);
            boolean result = updateById(user);
            
            if (result) {
                LogUtils.info(logger, () -> "【用户管理】用户密码更新成功，用户ID: " + userId);
                LogUtils.logSecurityEvent(logger, "PASSWORD_UPDATE_SUCCESS", "user_" + userId, "用户密码更新成功");
                LogUtils.debug(logger, () -> "【用户管理】密码更新完成，用户信息已保存到数据库，用户ID: " + userId);
            } else {
                LogUtils.warn(logger, "【用户管理】用户密码更新失败，用户ID: {}", userId);
                LogUtils.logSecurityEvent(logger, "PASSWORD_UPDATE_FAILED", "user_" + userId, "更新密码失败: 数据库操作失败");
            }
            
            LogUtils.logPerformance(logger, "updatePassword", startTime, System.currentTimeMillis());
            LogUtils.debug(logger, () -> "【用户管理】updatePassword方法执行完成，结果: " + result);
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【用户管理】更新用户密码异常: 用户ID: " + userId + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logSecurityEvent(logger, "PASSWORD_UPDATE_ERROR", "user_" + userId, "更新密码发生异常: " + e.getMessage());
            throw e;
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public boolean updateUserInfo(User user) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "USER_INFO_UPDATE_ATTEMPT", "user_" + (user != null ? user.getId() : "unknown"), "用户信息更新尝试开始");
        try {
            // 参数验证
            if (user == null) {
                LogUtils.warn(logger, "【用户管理】updateUserInfo方法参数验证失败: 用户对象为空");
                LogUtils.logBusiness(logger, "USER_INFO_UPDATE_FAILED", "unknown", "更新用户信息失败: 用户对象为空");
                return false;
            }
            if (user.getId() == null || user.getId() <= 0) {
                LogUtils.warn(logger, "【用户管理】updateUserInfo方法参数验证失败: 用户ID为空或非法值");
                LogUtils.logBusiness(logger, "USER_INFO_UPDATE_FAILED", "unknown", "更新用户信息失败: 用户ID非法");
                return false;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】开始执行updateUserInfo方法更新用户信息，用户ID: " + user.getId());
            LogUtils.debug(logger, () -> "【用户管理】updateUserInfo方法执行开始时间戳: " + startTime);
            
            // 查询用户是否存在
            LogUtils.debug(logger, () -> "【用户管理】根据用户ID查询用户信息，用户ID: " + user.getId());
            User existingUser = getById(user.getId());
            if (existingUser == null) {
                LogUtils.warn(logger, "【用户管理】更新用户信息失败: 用户不存在，用户ID: {}", user.getId());
                LogUtils.logBusiness(logger, "USER_INFO_UPDATE_FAILED", "user_" + user.getId(), "更新用户信息失败: 用户不存在");
                return false;
            }
            
            LogUtils.info(logger, () -> "【用户管理】用户存在，开始准备更新用户信息，用户ID: " + user.getId());
            // 不允许通过此接口修改密码
            LogUtils.debug(logger, () -> "【用户管理】设置密码为null，不允许通过此接口修改密码，用户ID: " + user.getId());
            user.setPassword(null);
            user.setUpdateTime(LocalDateTime.now());
            
            LogUtils.debug(logger, () -> "【用户管理】用户信息准备完成，开始更新用户信息到数据库，用户ID: " + user.getId());
            boolean result = updateById(user);
            
            if (result) {
                LogUtils.info(logger, () -> "【用户管理】用户信息更新成功，用户ID: " + user.getId());
                LogUtils.logBusiness(logger, "USER_INFO_UPDATE_SUCCESS", "user_" + user.getId(), "用户信息更新成功");
                // 记录更新的详细信息（但不记录敏感信息）
                LogUtils.debug(logger, () -> "【用户管理】用户信息更新完成详细信息: 用户ID=" + user.getId() + ", 用户名=" + user.getUsername() + ", 更新时间=" + user.getUpdateTime());
            } else {
                LogUtils.warn(logger, "【用户管理】用户信息更新失败，用户ID: {}", user.getId());
                LogUtils.logBusiness(logger, "USER_INFO_UPDATE_FAILED", "user_" + user.getId(), "更新用户信息失败: 数据库操作失败");
            }
            
            LogUtils.logPerformance(logger, "updateUserInfo", startTime, System.currentTimeMillis());
            LogUtils.debug(logger, () -> "【用户管理】updateUserInfo方法执行完成，结果: " + result);
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【用户管理】更新用户信息异常: 用户ID: " + (user != null ? user.getId() : "unknown") + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "USER_INFO_UPDATE_ERROR", "user_" + (user != null ? user.getId() : "unknown"), "更新用户信息发生异常: " + e.getMessage());
            throw e;
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public boolean deleteUser(Long userId) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "USER_DELETE_ATTEMPT", "admin", "用户删除尝试开始，用户ID: " + userId);
        try {
            // 参数验证
            if (userId == null || userId <= 0) {
                LogUtils.warn(logger, "【用户管理】deleteUser方法参数验证失败: 用户ID为空或非法值: " + userId);
                LogUtils.logBusiness(logger, "USER_DELETE_FAILED", "admin", "删除用户失败: 用户ID非法");
                return false;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】开始执行deleteUser方法删除用户，用户ID: " + userId);
            LogUtils.debug(logger, () -> "【用户管理】deleteUser方法执行开始时间戳: " + startTime);
            
            // 查询用户是否存在
            LogUtils.debug(logger, () -> "【用户管理】根据用户ID查询用户信息，用户ID: " + userId);
            User user = getById(userId);
            if (user == null) {
                LogUtils.warn(logger, "【用户管理】删除用户失败: 用户不存在，用户ID: {}", userId);
                LogUtils.logBusiness(logger, "USER_DELETE_FAILED", "admin", "删除用户失败: 用户不存在");
                return false;
            }
            
            LogUtils.info(logger, () -> "【用户管理】用户存在，开始执行删除操作，用户ID: " + userId + ", 用户名: " + user.getUsername());
            // 记录将要删除的用户信息，便于审计
            LogUtils.debug(logger, () -> "【用户管理】即将删除的用户详细信息: 用户ID=" + userId + ", 用户名=" + user.getUsername() + ", 状态=" + user.getStatus() + ", 创建时间=" + user.getCreateTime());
            
            boolean result = removeById(userId);
            
            if (result) {
                LogUtils.info(logger, () -> "【用户管理】用户删除成功，用户ID: " + userId + ", 用户名: " + user.getUsername());
                LogUtils.logBusiness(logger, "USER_DELETE_SUCCESS", "admin", "用户删除成功，用户ID: " + userId + ", 用户名: " + user.getUsername());
            } else {
                LogUtils.warn(logger, "【用户管理】用户删除失败，用户ID: {}", userId);
                LogUtils.logBusiness(logger, "USER_DELETE_FAILED", "admin", "删除用户失败: 数据库操作失败");
            }
            
            LogUtils.logPerformance(logger, "deleteUser", startTime, System.currentTimeMillis());
            LogUtils.debug(logger, () -> "【用户管理】deleteUser方法执行完成，结果: " + result);
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【用户管理】删除用户异常: 用户ID: " + userId + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "USER_DELETE_ERROR", "admin", "删除用户发生异常: " + e.getMessage());
            throw e;
        }
    }

    public IPage<User> getUserList(Integer pageNum, Integer pageSize, String keyword) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "USER_LIST_QUERY_START", "system", "准备分页查询用户列表");
        try {
            // 保存原始参数的final版本
            final Integer originalPageNum = pageNum;
            final Integer originalPageSize = pageSize;
            
            // 参数验证
            if (pageNum == null || pageNum <= 0) {
                pageNum = 1;
                LogUtils.warn(logger, "【用户管理】getUserList方法参数验证: 页码参数无效，自动设置为默认值: {}", pageNum);
            }
            if (pageSize == null || pageSize <= 0) {
                pageSize = 10;
                LogUtils.warn(logger, "【用户管理】getUserList方法参数验证: 每页大小参数无效，自动设置为默认值: {}", pageSize);
            }
            
            // 创建处理后参数的final版本
            final Integer finalPageNum = pageNum;
            final Integer finalPageSize = pageSize;
            
            LogUtils.debug(logger, () -> "【用户管理】开始执行getUserList方法分页查询用户列表，页码: " + finalPageNum + ", 每页大小: " + finalPageSize + ", 关键词: " + (keyword != null ? keyword : "空"));
            LogUtils.debug(logger, () -> "【用户管理】getUserList方法执行开始时间戳: " + startTime);
            
            LogUtils.debug(logger, () -> "【用户管理】创建分页对象，页码: " + finalPageNum + ", 每页大小: " + finalPageSize);
            Page<User> page = new Page<>(pageNum, pageSize);
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            
            // 构建查询条件
            LogUtils.debug(logger, () -> "【用户管理】开始构建查询条件，关键词: " + (keyword != null ? keyword : "空"));
            if (keyword != null && !keyword.isEmpty()) {
                LogUtils.debug(logger, () -> "【用户管理】添加关键词搜索条件: " + keyword);
                queryWrapper.like("username", keyword).or().like("real_name", keyword);
            }
            
            // 设置排序
            LogUtils.debug(logger, () -> "【用户管理】设置排序条件: 按创建时间倒序");
            queryWrapper.orderByDesc("create_time");
            
            LogUtils.debug(logger, () -> "【用户管理】执行分页查询，调用page方法");
            IPage<User> result = page(page, queryWrapper);
            
            LogUtils.info(logger, () -> "【用户管理】查询用户列表成功，总记录数: " + result.getTotal() + ", 页数: " + result.getPages() + ", 当前页记录数: " + result.getRecords().size());
            LogUtils.logBusiness(logger, "USER_LIST_QUERY_SUCCESS", "system", "分页查询用户列表成功，总记录数: " + result.getTotal() + ", 页数: " + result.getPages());
            
            LogUtils.logPerformance(logger, "getUserList", startTime, System.currentTimeMillis());
            LogUtils.debug(logger, () -> "【用户管理】getUserList方法执行完成，返回分页查询结果");
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【用户管理】查询用户列表异常: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "USER_LIST_QUERY_ERROR", "system", "分页查询用户列表发生异常: " + e.getMessage());
            throw e;
        }
    }

    public boolean updateUserStatus(Long userId, Integer status) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "USER_STATUS_UPDATE_ATTEMPT", "admin", "用户状态更新尝试开始，用户ID: " + userId + ", 状态: " + status);
        try {
            // 参数验证
            if (userId == null || userId <= 0) {
                LogUtils.warn(logger, "【用户管理】updateUserStatus方法参数验证失败: 用户ID为空或非法值: " + userId);
                LogUtils.logBusiness(logger, "USER_STATUS_UPDATE_FAILED", "admin", "更新用户状态失败: 用户ID非法");
                return false;
            }
            if (status == null || (status != 0 && status != 1)) {
                LogUtils.warn(logger, "【用户管理】updateUserStatus方法参数验证失败: 状态值无效: " + status);
                LogUtils.logBusiness(logger, "USER_STATUS_UPDATE_FAILED", "admin", "更新用户状态失败: 状态值无效");
                return false;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】开始执行updateUserStatus方法更新用户状态，用户ID: " + userId + ", 目标状态: " + status);
            LogUtils.debug(logger, () -> "【用户管理】updateUserStatus方法执行开始时间戳: " + startTime);
            
            // 查询用户是否存在
            LogUtils.debug(logger, () -> "【用户管理】根据用户ID查询用户信息，用户ID: " + userId);
            User user = getById(userId);
            if (user == null) {
                LogUtils.warn(logger, "【用户管理】更新用户状态失败: 用户不存在，用户ID: {}", userId);
                LogUtils.logBusiness(logger, "USER_STATUS_UPDATE_FAILED", "admin", "更新用户状态失败: 用户不存在");
                return false;
            }
            
            LogUtils.info(logger, () -> "【用户管理】用户存在，开始更新用户状态，用户ID: " + userId + ", 当前状态: " + user.getStatus() + ", 目标状态: " + status);
            // 如果状态没有变化，直接返回成功
            if (user.getStatus() == status) {
                LogUtils.debug(logger, () -> "【用户管理】用户状态没有变化，无需更新，用户ID: " + userId + ", 状态: " + status);
                LogUtils.logBusiness(logger, "USER_STATUS_UPDATE_NO_CHANGE", "admin", "用户状态没有变化，无需更新，用户ID: " + userId + ", 状态: " + status);
                return true;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】更新用户状态值，设置更新时间，用户ID: " + userId);
            user.setStatus(status);
            user.setUpdateTime(LocalDateTime.now());
            
            LogUtils.debug(logger, () -> "【用户管理】用户状态信息准备完成，开始保存更新后的用户信息，用户ID: " + userId);
            boolean result = updateById(user);
            
            if (result) {
                LogUtils.info(logger, () -> "【用户管理】用户状态更新成功，用户ID: " + userId + ", 新状态: " + status);
                LogUtils.logBusiness(logger, "USER_STATUS_UPDATE_SUCCESS", "admin", "用户状态更新成功，用户ID: " + userId + ", 新状态: " + status);
                LogUtils.debug(logger, () -> "【用户管理】用户状态更新完成详细信息: 用户ID=" + userId + ", 用户名=" + user.getUsername() + ", 新状态=" + status + ", 更新时间=" + user.getUpdateTime());
            } else {
                LogUtils.warn(logger, "【用户管理】用户状态更新失败，用户ID: {}", userId);
                LogUtils.logBusiness(logger, "USER_STATUS_UPDATE_FAILED", "admin", "更新用户状态失败: 数据库操作失败");
            }
            
            LogUtils.logPerformance(logger, "updateUserStatus", startTime, System.currentTimeMillis());
            LogUtils.debug(logger, () -> "【用户管理】updateUserStatus方法执行完成，结果: " + result);
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【用户管理】更新用户状态异常: 用户ID: " + userId + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "USER_STATUS_UPDATE_ERROR", "admin", "更新用户状态发生异常: " + e.getMessage());
            throw e;
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean resetPassword(Long userId, String newPassword) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "USER_PASSWORD_RESET_ATTEMPT", "admin", "用户密码重置尝试开始，用户ID: " + userId);
        try {
            // 参数验证
            if (userId == null || userId <= 0) {
                LogUtils.warn(logger, "【用户管理】resetPassword方法参数验证失败: 用户ID为空或非法值: " + userId);
                LogUtils.logBusiness(logger, "USER_PASSWORD_RESET_FAILED", "admin", "重置用户密码失败: 用户ID非法");
                return false;
            }
            if (newPassword == null || newPassword.trim().isEmpty()) {
                LogUtils.warn(logger, "【用户管理】resetPassword方法参数验证失败: 新密码为空，用户ID: {}", userId);
                LogUtils.logBusiness(logger, "USER_PASSWORD_RESET_FAILED", "admin", "重置用户密码失败: 新密码为空");
                return false;
            }
            
            LogUtils.debug(logger, () -> "【用户管理】开始执行resetPassword方法重置用户密码，用户ID: " + userId);
            LogUtils.debug(logger, () -> "【用户管理】resetPassword方法执行开始时间戳: " + startTime);
            
            // 查询用户是否存在
            LogUtils.debug(logger, () -> "【用户管理】根据用户ID查询用户信息，用户ID: " + userId);
            User user = getById(userId);
            if (user == null) {
                LogUtils.warn(logger, "【用户管理】重置用户密码失败: 用户不存在，用户ID: {}", userId);
                LogUtils.logBusiness(logger, "USER_PASSWORD_RESET_FAILED", "admin", "重置用户密码失败: 用户不存在");
                return false;
            }
            
            LogUtils.info(logger, () -> "【用户管理】用户存在，开始重置用户密码，用户ID: " + userId + ", 用户名: " + user.getUsername());
            // 加密新密码
            LogUtils.debug(logger, () -> "【用户管理】开始加密新密码，用户ID: " + userId);
            user.setPassword(passwordEncoder.encode(newPassword));
            user.setUpdateTime(LocalDateTime.now());
            
            LogUtils.debug(logger, () -> "【用户管理】密码加密完成，开始保存更新后的用户信息，用户ID: " + userId);
            boolean result = updateById(user);
            
            if (result) {
                LogUtils.info(logger, () -> "【用户管理】用户密码重置成功，用户ID: " + userId);
                LogUtils.logBusiness(logger, "USER_PASSWORD_RESET_SUCCESS", "admin", "用户密码重置成功，用户ID: " + userId);
                LogUtils.debug(logger, () -> "【用户管理】密码重置完成，用户信息已保存到数据库，用户ID: " + userId + ", 更新时间: " + user.getUpdateTime());
            } else {
                LogUtils.warn(logger, "【用户管理】用户密码重置失败，用户ID: {}", userId);
                LogUtils.logBusiness(logger, "USER_PASSWORD_RESET_FAILED", "admin", "重置用户密码失败: 数据库操作失败");
            }
            
            LogUtils.logPerformance(logger, "resetPassword", startTime, System.currentTimeMillis());
            LogUtils.debug(logger, () -> "【用户管理】resetPassword方法执行完成，结果: " + result);
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【用户管理】重置用户密码异常: 用户ID: " + userId + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "USER_PASSWORD_RESET_ERROR", "admin", "重置用户密码发生异常: " + e.getMessage());
            throw e;
        }
    }
    
    @Override
    public Map<String, Object> getUserList(Integer page, Integer pageSize, Map<String, Object> params) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "USER_LIST_MAP_QUERY_START", "system", "准备带条件分页查询用户列表");
        try {
            // 保存原始参数的final版本
            final Integer originalPage = page;
            final Integer originalPageSize = pageSize;
            final Map<String, Object> originalParams = params;
            
            // 参数验证
            if (page == null || page <= 0) {
                page = 1;
                LogUtils.warn(logger, "【用户管理】getUserList方法参数验证: 页码参数无效，自动设置为默认值: {}", page);
            }
            if (pageSize == null || pageSize <= 0) {
                pageSize = 10;
                LogUtils.warn(logger, "【用户管理】getUserList方法参数验证: 每页大小参数无效，自动设置为默认值: {}", pageSize);
            }
            if (params == null) {
                params = new HashMap<>();
                LogUtils.warn(logger, "【用户管理】getUserList方法参数验证: 查询参数为空，使用空Map替代");
            }
            
            // 创建处理后参数的final版本
            final Integer finalPage = page;
            final Integer finalPageSize = pageSize;
            final Map<String, Object> finalParams = params;
            
            LogUtils.debug(logger, () -> "【用户管理】开始执行带条件的getUserList方法分页查询用户列表，页码: " + finalPage + ", 每页大小: " + finalPageSize + ", 搜索参数: " + (finalParams != null ? finalParams : "空"));
            LogUtils.debug(logger, () -> "【用户管理】getUserListMap方法执行开始时间戳: " + startTime);
            
            LogUtils.debug(logger, () -> "【用户管理】创建分页对象，页码: " + finalPage + ", 每页大小: " + finalPageSize);
            IPage<User> userPage = new Page<>(page, pageSize);
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            
            // 根据参数构建查询条件
            LogUtils.debug(logger, () -> "【用户管理】开始根据参数构建查询条件");
            if (params != null) {
                LogUtils.debug(logger, () -> "【用户管理】参数不为空，开始处理各个查询条件");
                // 用户名搜索
                if (finalParams.containsKey("username") && finalParams.get("username") != null && !finalParams.get("username").toString().isEmpty()) {
                    String username = finalParams.get("username").toString();
                    LogUtils.debug(logger, () -> "【用户管理】添加用户名搜索条件: " + username);
                    queryWrapper.like("username", username);
                }
                
                // 状态筛选
                if (finalParams.containsKey("status") && finalParams.get("status") != null) {
                    LogUtils.debug(logger, () -> "【用户管理】添加状态筛选条件: " + finalParams.get("status"));
                    try {
                        Integer status = Integer.parseInt(finalParams.get("status").toString());
                        queryWrapper.eq("status", status);
                        LogUtils.debug(logger, () -> "【用户管理】状态筛选条件设置成功: " + status);
                    } catch (NumberFormatException e) {
                        // 忽略格式错误
                        LogUtils.warn(logger, "【用户管理】用户状态参数格式错误: {}", finalParams.get("status"));
                    }
                }
                
                // 角色ID筛选
                if (finalParams.containsKey("roleId") && finalParams.get("roleId") != null) {
                    LogUtils.debug(logger, () -> "【用户管理】添加角色ID筛选条件: " + finalParams.get("roleId"));
                    try {
                        Long roleId = Long.parseLong(finalParams.get("roleId").toString());
                        queryWrapper.eq("role_id", roleId);
                        LogUtils.debug(logger, () -> "【用户管理】角色ID筛选条件设置成功: " + roleId);
                    } catch (NumberFormatException e) {
                        // 忽略格式错误
                        LogUtils.warn(logger, "【用户管理】角色ID参数格式错误: {}", finalParams.get("roleId"));
                    }
                }
                
                // 记录已处理的查询条件数量
                LogUtils.debug(logger, () -> "【用户管理】查询条件处理完成，共处理 " + finalParams.size() + " 个参数");
            } else {
                LogUtils.debug(logger, () -> "【用户管理】查询参数为空，不添加额外筛选条件");
            }
            
            // 按创建时间倒序排序
            LogUtils.debug(logger, () -> "【用户管理】设置排序条件: 按创建时间倒序");
            queryWrapper.orderByDesc("create_time");
            
            LogUtils.debug(logger, () -> "【用户管理】执行分页查询，调用userMapper.selectPage方法");
            IPage<User> userPageResult = userMapper.selectPage(userPage, queryWrapper);
            
            // 创建final变量供lambda表达式使用
            final IPage<User> finalUserPage = userPageResult;
            
            // 移除敏感信息
            LogUtils.debug(logger, () -> "【用户管理】开始处理查询结果，移除敏感信息");
            List<User> userList = userPageResult.getRecords().stream()
                    .map(user -> {
                        user.setPassword(null);
                        return user;
                    })
                    .collect(Collectors.toList());
            
            LogUtils.debug(logger, () -> "【用户管理】敏感信息移除完成，开始构建返回结果");
            Map<String, Object> result = new HashMap<>();
            result.put("list", userList);
            result.put("total", userPageResult.getTotal());
            
            LogUtils.info(logger, () -> "【用户管理】查询用户列表成功，总记录数: " + finalUserPage.getTotal() + ", 页数: " + finalUserPage.getPages() + ", 当前页记录数: " + userList.size());
            LogUtils.logBusiness(logger, "USER_LIST_MAP_QUERY_SUCCESS", "system", "带条件分页查询用户列表成功，总记录数: " + finalUserPage.getTotal() + ", 页数: " + finalUserPage.getPages());
            
            LogUtils.logPerformance(logger, "getUserListMap", startTime, System.currentTimeMillis());
            LogUtils.debug(logger, () -> "【用户管理】带条件的getUserList方法执行完成，返回查询结果");
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【用户管理】查询用户列表异常: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "USER_LIST_MAP_QUERY_ERROR", "system", "带条件分页查询用户列表发生异常: " + e.getMessage());
            throw e;
        }
    }
}